package org.aplombh.java.awcing.basic.dp.knapsack;

import java.util.Scanner;
import java.util.TreeMap;

/**
 * 有 N 件物品和一个容量是 V 的背包。每件物品只能使用一次。
 * <p>
 * 第 i 件物品的体积是 vi，价值是 wi。
 * <p>
 * 求解将哪些物品装入背包，可使这些物品的总体积不超过背包容量，且总价值最大。
 * 输出最大价值。
 * <p>
 * 输入格式
 * 第一行两个整数，N，V，用空格隔开，分别表示物品数量和背包容积。
 * <p>
 * 接下来有 N 行，每行两个整数 vi,wi，用空格隔开，分别表示第 i 件物品的体积和价值。
 * <p>
 * 输出格式
 * 输出一个整数，表示最大价值。
 * <p>
 * 数据范围
 * 0<N,V≤1000
 * 0<vi,wi≤1000
 * 输入样例
 * 4 5
 * 1 2
 * 2 4
 * 3 4
 * 4 5
 * 输出样例：
 * 8
 */
public class KnapsackProblem_2 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int n = scanner.nextInt();
        int m = scanner.nextInt();
        KnapsackProblem knapsackProblem = new KnapsackProblem(n, m);
//        KnapsackProblemOptimize knapsackProblem = new KnapsackProblemOptimize(n, m);
        for (int i = 1; i <= n; i++) {
            knapsackProblem.v[i] = scanner.nextInt();
            knapsackProblem.w[i] = scanner.nextInt();
        }
        System.out.println(knapsackProblem.solve());
        knapsackProblem.trace();
    }
}


/**
 * f[i][j] 表示只看前i个物品，总体积是j的情况下，总价值最大是多少。
 * <p>
 * result = max{f[n][0~V]}
 * f[i][j]:
 * 1.不选第i个物品，f[i][j] = f[i - 1][j];
 * 2. 选第i个物品，f[i][j] = f[i - 1][j 一v[i]];
 * <p>
 * f[i][j] = max{1. 2.}
 * f[0][0] = 0;
 */
class KnapsackProblem {
    public static final int N = 1010;
    int n, m;
    int[][] f = new int[N][N];
    int[] v = new int[N];
    int[] w = new int[N];
    int[] trace = new int[N];

    public KnapsackProblem(int n, int m) {
        this.n = n;
        this.m = m;
    }

    public int solve() {
        for (int i = 1; i <= n; i++) {
            for (int j = 1; j <= m; j++) {

                f[i][j] = f[i - 1][j];
                if (j >= v[i]) {

                    // f[i][j] 表示只看前i个物品，总体积是j的情况下，总价值最大是多少。
                    //
                    // [0, 0, 0, 0, 0, 0, 0]
                    // [0, 2, 2, 2, 2, 2, 0]
                    // [0, 2, 4, 6, 6, 6, 0]
                    // [0, 2, 4, 6, 6, 8, 0]
                    // [0, 2, 4, 6, 6, 8, 0]
                    // [0, 0, 0, 0, 0, 0, 0]
                    f[i][j] = Math.max(f[i][j], f[i - 1][j - v[i]] + w[i]);
                }
            }
        }

        return f[n][m];
    }

    public void trace() {
        // m为总体积
        int c = m;
        for (int i = n; i > 1; i--) {
            // 如果相同表示未选该物品
            if (f[i][c] == f[i - 1][c]) {
                trace[i] = 0;
            } else {
                // 选了该物品,占用多大体积,体积减少
                trace[i] = 1;
                c -= v[i];
            }
        }
        for (int i = 1; i <= n; i++) {
            System.out.print(trace[i]+" ");
        }
        System.out.println();
    }
}

class KnapsackProblemOptimize {
    public static final int N = 1010;
    int n, m;
    int[] f = new int[N];
    int[] v = new int[N];
    int[] w = new int[N];
    int[] trace = new int[N];

    public KnapsackProblemOptimize(int n, int m) {
        this.n = n;
        this.m = m;
    }

    public int solve() {
        for (int i = 1; i <= n; i++) {
//            for (int j = 1; j <= m; j++) {
            // 保证每次f[j-v[i]]使用的是上一层的未改变的值 Ensure that f[j-v[I]] uses the same value of the previous layer each time
            for (int j = m; j >= v[i]; j--) {
                f[j] = Math.max(f[j], f[j - v[i]] + w[i]);
            }
        }
        return f[m];
    }
}
